package cn.wlinker.video.monitor.stream;

import cn.wlinker.video.monitor.utils.ThreadPoolUtils;
import lombok.extern.slf4j.Slf4j;

import java.io.InputStream;
import java.util.Iterator;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 转换器注册器
 *
 * @author gxsjx
 * @version 1.0
 * @date 2025/5/3
 * Copyright © wlinker.cn
 */
@Slf4j
public class ConverterRegistration {

    /**
     * 转换器集合（根据用户ID分类）
     */
    private static final ConcurrentHashMap<String,Converter> converters = new ConcurrentHashMap<>();

    /**
     * 开始一个转换<br/>
     * 如果已存在这个流的转换就直接返回已存在的转换器
     *
     * @param steamId 流id
     * @return converter
     * @author xufeng
     */
    public static Converter open(InputStream inputStream, String steamId) {
        synchronized (steamId.intern()) {
            log.info("===开始一个转换==={}", steamId);
            //判断当前用户是否存在转换器线程集合，没有则新建
            //判断是否已存在该转换器
            Converter c = isExistStream(steamId);
            log.info("===判断是否已经存在转换器=={}", c);
            try {
                if (null == c) {
                    String key = UUID.randomUUID().toString();
                    //创建线程
                    c = new ConverterFactories(steamId, inputStream, UUID.randomUUID().toString());
                    //记录到集合
                    converters.put(steamId, c);
                    //用线程池启动
                    ThreadPoolUtils.execute((Runnable) c);
                }
            } catch (Exception e) {
                log.error("开始一个转换异常", e);
            }
            //如果该线程存在，但处于停止状态，则重新设置状态播放
            assert c != null;
            if (!c.isRunning()) {
                //设置运行状态
                //设置初始化标志
                c.setState(ConverterState.INITIAL);
                //线程池启动
                ThreadPoolUtils.execute((Runnable) c);
            }
            return c;
        }
    }


    /**
     * 开始一个转换<br/>
     * 如果已存在这个流的转换就直接返回已存在的转换器
     *
     * @param url     视频流链接
     * @param steamId 流id
     * @return converter
     * @author xufeng
     */
    public static Converter open(String url, String steamId) {
        synchronized (steamId.intern()) {
            log.info("===开始一个转换==={}", url);
            //判断当前用户是否存在转换器线程集合，没有则新建
            //判断是否已存在该转换器
            Converter c = isExistStream(steamId);
            log.info("===判断是否已经存在转换器=={}", c);
            try {
                if (null == c) {
                    String key = UUID.randomUUID().toString();
                    //创建线程
                    c = new ConverterFactories(url, UUID.randomUUID().toString());
                    //记录到集合
                    converters.put(steamId, c);
                    //用线程池启动
                    ThreadPoolUtils.execute((Runnable) c);
                }
            } catch (Exception e) {
                log.error("开始一个转换异常", e);
            }
            //如果该线程存在，但处于停止状态，则重新设置状态播放
            assert c != null;
            if (!c.isRunning()) {
                //设置初始化标志
                c.setState(ConverterState.INITIAL);
                //线程池启动
                ThreadPoolUtils.execute((Runnable) c);
            }
            return c;
        }
    }

    public static Converter isExistUrl(String url) {
        //遍历集合，根据url判断是否已存在该流视频
        for (String key : converters.keySet()) {
            Converter c = converters.get(key);
            if (c.getUrl().equals(url)) {
                return c;
            }
        }
        return null;
    }

    /**
     * 如果流已存在，就共用一个
     *
     * @return converter
     * @author xufeng
     */
    public static Converter isExistStream(String streamId) {
        return converters.get(streamId);
    }

    /**
     * 返回集合中的所有转换器
     *
     * @param streamId 流id
     * @return converters
     * @author xufeng
     */
    public static Converter getConverter(String streamId) {
        return converters.get(streamId);
    }

    /**
     * 移除一个转换器
     */
    public static void removeConverter(String streamId) {
        if (null != converters.get(streamId)) {
            converters.get(streamId).exit();
        }
        converters.remove(streamId);
    }

    /**
     * 通过url移除一个转换器
     */
    public static void removeConverterByUrl(String url) {
        //使用迭代器的方式移除
        Iterator<String> iterator = converters.keySet().iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            if (converters.get(next).getUrl().equals(url)) {
                converters.get(next).exit();
                iterator.remove();
            }
        }
    }
}